/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package kingdoms;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import kingdoms.rede.AtorNetGames;
import kingdoms.rede.Mensagem;
import kingdoms.rede.TipoMensagem;

/**
 *
 * @author fernando
 */
public class Tabuleiro extends JFrame {

    private JPanel panelPosicoes;
    private JPanel panelPrincipal;
    private int linhas;
    private int colunas;
    private Posicao[][] posicoes;
    private int qtdePecasLivresTabuleiro;
    private EnumTipoPeca[] tiposPecas = EnumTipoPeca.values();
    private HashMap<EnumTipoPeca, ImageIcon> mapTipoPecaImageIcon = new HashMap<EnumTipoPeca, ImageIcon>(tiposPecas.length);
    //
    private AtorNetGames atorNetgames;
    private Partida partida;
    //
    private String ipServidorNetgames = "127.0.0.1";

    public Tabuleiro(int linhas, int colunas) throws IOException {
        this.linhas = linhas;
        this.colunas = colunas;

        this.qtdePecasLivresTabuleiro = linhas * colunas;
        //
        this.posicoes = new Posicao[linhas][colunas];
        //
        this.setSize(1024, 755);
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//        this.setResizable(false);
        //
        construirBarraMenu();
        //
        associarPecasAsImagens();
        //
//        iniciarPartidaOffline();
    }

    private void associarPecasAsImagens() {
        try {
            mapTipoPecaImageIcon.put(EnumTipoPeca.CASTELO, new ImageIcon(ImageIO.read(Arquivos.imagemCastelo)));

            mapTipoPecaImageIcon.put(EnumTipoPeca.DRAGAO, new ImageIcon(ImageIO.read(Arquivos.imagemDragao)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.MOINHO, new ImageIcon(ImageIO.read(Arquivos.imagemMoinho)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.PANTANO, new ImageIcon(ImageIO.read(Arquivos.imagemPantano)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.MINA, new ImageIcon(ImageIO.read(Arquivos.imagemMina)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.BANDIDO, new ImageIcon(ImageIO.read(Arquivos.imagemBandido)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.OGRO, new ImageIcon(ImageIO.read(Arquivos.imagemOgro)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.TORRE, new ImageIcon(ImageIO.read(Arquivos.imagemTorre)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.MONTANHA, new ImageIcon(ImageIO.read(Arquivos.imagemMontanha)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.TROLL, new ImageIcon(ImageIO.read(Arquivos.imagemTroll)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.MERCADO, new ImageIcon(ImageIO.read(Arquivos.imagemMercado)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.LOBOS, new ImageIcon(ImageIO.read(Arquivos.imagemLobo)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.LAVOURA, new ImageIcon(ImageIO.read(Arquivos.imagemLavoura)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.VILAREJO, new ImageIcon(ImageIO.read(Arquivos.imagemVilarejo)));
            mapTipoPecaImageIcon.put(EnumTipoPeca.FAZENDA, new ImageIcon(ImageIO.read(Arquivos.imagemFazenda)));

        } catch (IOException ex) {
            Logger.getLogger(Tabuleiro.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void construirBarraMenu() {
        JMenuBar barraMenu = new JMenuBar();
        setJMenuBar(barraMenu);
        //
        JMenu menuJogar = new JMenu();
        menuJogar.setText("Jogar");
        barraMenu.add(menuJogar);
        //
        JMenu menuConfiguracoes = new JMenu();
        menuConfiguracoes.setText("Configuracoes");
        barraMenu.add(menuConfiguracoes);
        //
        JMenu menuAjuda = new JMenu();
        menuAjuda.setText("Ajuda");
        barraMenu.add(menuAjuda);
        //
        JMenuItem menuRede = new JMenuItem("Rede");
        menuRede.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String ipServidorNetgamesTmp = JOptionPane.showInputDialog("IP Servidor NetGames (ex.: 127.0.0.1)", ipServidorNetgames);
                if (ipServidorNetgamesTmp == null || ipServidorNetgamesTmp.trim().isEmpty()) {
                    exibirMensagem("acao cancelada");
                    return;
                }
                ipServidorNetgames = ipServidorNetgamesTmp;
                exibirMensagem("Novo endereco NetGames: " + ipServidorNetgames);
            }
        });
        menuConfiguracoes.add(menuRede);

        JMenuItem menuRanking = new JMenuItem("Ranking");
        menuRanking.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                Tabuleiro.this.exibirRanking();
            }
        });
        menuConfiguracoes.add(menuRanking);
        //
        JMenuItem menuNovoJogoEmRede = new JMenuItem("Novo Jogo em REDE");
        menuNovoJogoEmRede.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("novo jogo em rede");
                destruirPanelJogo();
                iniciarPartidaEmRede();
            }
        });
        menuJogar.add(menuNovoJogoEmRede);
        //
        JMenuItem menuNovoJogo = new JMenuItem("Novo Jogo");
        menuNovoJogo.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("novo jogo");
                destruirPanelJogo();
                iniciarPartidaOffline();
            }
        });
        menuJogar.add(menuNovoJogo);
        //
        JMenuItem menuAjudaSobre = new JMenuItem("Sobre");
        menuAjudaSobre.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                StringBuilder sb = new StringBuilder();
                sb.append("Kingdoms").append("\n");
                sb.append("Players cannot move tiles once they have been placed.").append("\n")
                        .append("They must also play their castle tiles when there are still empty places on the board").append("\n")
                        .append("else they risk not scoring the best rows and columns.").append("\n")
                        .append("This requires tactical thinking;").append("\n")
                        .append("each player must balance the need to score points with the risk of having").append("\n")
                        .append("their valuable castles negated with a dragon or hazard tile later in the round.");
                exibirMensagem(sb.toString());
            }
        });
        menuAjuda.add(menuAjudaSobre);
        //

    }

    private void construirPainelGrid() throws IOException {
        panelPosicoes = new JPanel(new GridLayout(linhas, colunas, 3, 3));
        panelPosicoes.setBounds(0, 0, linhas * 100, colunas * 100);

        ImageIcon vazio = new ImageIcon(ImageIO.read(Arquivos.imagemVazio));
        for (int j = 0; j < linhas; j++) {
            for (int i = 0; i < colunas; i++) {
                Posicao pos = new Posicao(j, i, j + ":" + i, vazio);
                adicionarEventoCliqueSelecao(pos);
                panelPosicoes.add(pos);
                posicoes[j][i] = pos;
                pos.setPreferredSize(new Dimension(100, 100));
//                pos.setSize(new Dimension(100, 100));
            }
        }
    }

    private void adicionarEventoCliqueSelecao(final Posicao pos) {
        pos.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                regraCliquePosicao(pos);
            }
        });
    }

//    private void construirPainelJogadores() throws IOException {
//        jogador1.criarPanelJogador(this);
//        jogador2.criarPanelJogador(this);
//    }
    private void construirPecasParaCadaJogador() {
        //
        //pecas jogador 1
        List<Peca> pecasJogador1;
        try {
            pecasJogador1 = criarPecasCasteloJogador("vermelho");

            partida.getJogador1().setPecas(pecasJogador1);
            partida.getJogador1().criarPainelBaralho();
            //
            //pecas jogador 2
            List<Peca> pecasJogador2 = criarPecasCasteloJogador("azul");
            partida.getJogador2().setPecas(pecasJogador2);
            partida.getJogador2().criarPainelBaralho();

        } catch (IOException ex) {
            Logger.getLogger(Tabuleiro.class.getName()).log(Level.SEVERE, null, ex);
        }
        //
    }

    private LinkedList<Peca> criarPecasCasteloJogador(String cor) throws IOException {
        LinkedList<Peca> pecas = new LinkedList<Peca>();

        String nomeImagem = "./imagens/castelo-" + cor;

        for (int i = 0; i < 2; i++) {
            Peca tmpPeca = new Peca(EnumTipoPeca.CASTELO.name(), EnumTipoPeca.CASTELO, new ImageIcon(ImageIO.read(new File(nomeImagem + "-" + 1 + ".png"))), 1);

            tmpPeca.setPreferredSize(new Dimension(90, 90));
            pecas.add(tmpPeca);
        }

        for (int i = 0; i < 3; i++) {
            Peca tmpPeca = new Peca(EnumTipoPeca.CASTELO.name(), EnumTipoPeca.CASTELO, new ImageIcon(ImageIO.read(new File(nomeImagem + "-" + 2 + ".png"))), 2);

            tmpPeca.setPreferredSize(new Dimension(90, 90));
            pecas.add(tmpPeca);
        }

        for (int i = 0; i < 2; i++) {
            Peca tmpPeca = new Peca(EnumTipoPeca.CASTELO.name(), EnumTipoPeca.CASTELO, new ImageIcon(ImageIO.read(new File(nomeImagem + "-" + 3 + ".png"))), 3);

            tmpPeca.setPreferredSize(new Dimension(90, 90));
            pecas.add(tmpPeca);
        }

        Peca tmpPeca = new Peca(EnumTipoPeca.CASTELO.name(), EnumTipoPeca.CASTELO, new ImageIcon(ImageIO.read(new File(nomeImagem + "-" + 4 + ".png"))), 4);
        tmpPeca.setPontos(4);
        tmpPeca.setPreferredSize(new Dimension(90, 90));
        pecas.add(tmpPeca);

        return pecas;
    }

    public Peca criarPecaAleatoria() {
        int tipo = 1;
        Random r = new Random();
        int numeroRandomico = r.nextInt();

        if (numeroRandomico < 0) {
            numeroRandomico = numeroRandomico * -1;
        }

        tipo = numeroRandomico % 14 + 1;

        EnumTipoPeca etp = EnumTipoPeca.values()[tipo];

        Peca peca = new Peca(etp.name(), etp, mapTipoPecaImageIcon.get(etp), getPontosDaPeca(etp));

        return peca;
    }

    private int getPontosDaPeca(EnumTipoPeca tipoPeca) {
        switch (tipoPeca) {
            case BANDIDO:
                return -4;
            case CASTELO:
                return 0;
            case DRAGAO:
                return 0;
            case FAZENDA:
                return 2;
            case LAVOURA:
                return 1;
            case LOBOS:
                return -3;
            case MERCADO:
                return 5;
            case MINA:
                return 0;
            case MOINHO:
                return 4;
            case MONTANHA:
                return 0;
            case OGRO:
                return -6;
            case PANTANO:
                return -1;
            case TORRE:
                return 6;
            case TROLL:
                return -4;
            case VILAREJO:
                return 3;

            default:
                return 0;
        }
    }

    public void exibirMensagem(String mensagem) {
        JOptionPane.showMessageDialog(this, mensagem);
    }

    private void criarElementosGraficosPartida() {
        try {
            construirPainelGrid();
            //
            //
//            construirPainelJogadores();
            //
            //
            panelPrincipal = new JPanel();//new GridLayout(3, 1));

            this.add(panelPrincipal);
            //

            panelPrincipal.add(partida.getJogador2());

            panelPrincipal.add(panelPosicoes);

            panelPrincipal.add(partida.getJogador1());
            //
            panelPrincipal.revalidate();

        } catch (IOException ex) {
            Logger.getLogger(Tabuleiro.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void destruirPanelJogo() {
        if (panelPrincipal != null) {
            remove(panelPrincipal);
            panelPrincipal.remove(partida.getJogador1());
            panelPrincipal.remove(partida.getJogador1());
            //

            panelPrincipal = null;
            //
            System.gc();
            repaint();
        }
    }

    //fim criacao da interface
    //inicio regra de negocio
    private void iniciarPartidaEmRede() {
        String nomeJogador = "";
        while (nomeJogador.isEmpty()) {
            nomeJogador = JOptionPane.showInputDialog(this, "Qual seu nome?");
            if (nomeJogador == null) {
                return;
            }
        }
        partida = new Partida();
        partida.setPartidaEmRede(true);
        //jogador1 = new Jogador(1, nomeJogador, Color.red);
        partida.setJogador1(new AtorJogador(this, 1, nomeJogador, Color.red));
        partida.getJogador1().verificarDecks();

        partida.setJogador2(new AtorJogador(this, 2, nomeJogador, Color.red));
        partida.getJogador2().verificarDecks();

        this.atorNetgames = new AtorNetGames(this);
        boolean sucessoConectar = this.atorNetgames.conectar(ipServidorNetgames, partida.getJogador1().getNome());
        if (sucessoConectar) {
            this.atorNetgames.iniciarPartida();
        }

    }

    private void iniciarPartidaOffline() {
        String nomeJogador = "";
        while (nomeJogador.isEmpty()) {
            nomeJogador = JOptionPane.showInputDialog(this, "Qual seu nome?");
            if (nomeJogador == null) {
                return;
            }
        }
        partida = new Partida();
        partida.setPartidaEmRede(false);

        partida.setJogador1(new AtorJogador(this, 1, nomeJogador, Color.RED));
        partida.setJogador2(new AtorJogador(this, 2, "Outro", Color.BLUE));

        partida.getJogador1().verificarDecks();
        partida.getJogador2().verificarDecks();

        partida.iniciar();
        //

        construirPecasParaCadaJogador();
        //
        criarElementosGraficosPartida();
        //
        //TODO[fernando] xunxo para comecar
        partida.alternarJogadorDaVez();

    }

    private void iniciarNovaRodada() {
        //
        contarPontosJogadores();
        atualizarPlacar();
        //
        if (!partida.isPartidaEmAndamento()) {
            exibeMensagemGanhador();
        }
        //
        for (int i = 0; i < linhas; i++) {
            for (int j = 0; j < colunas; j++) {
                posicoes[i][j].setJogadorDono(null);
                posicoes[i][j].setPeca(null);
                try {
                    posicoes[i][j].setIcon(new ImageIcon(ImageIO.read(Arquivos.imagemVazio)));
                } catch (IOException ex) {
                    Logger.getLogger(Tabuleiro.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
        if(partida.isPartidaEmAndamento()){
            exibirMensagem("Iniciando rodada: " + partida.getRodadaAtual());
        }
        qtdePecasLivresTabuleiro = linhas * colunas;
        //
        //brute force muhauahauh
        repaint();
        invalidate();
    }

    private void regraCliquePosicao(Posicao posicaoClicada) {

        if (partida.getJogadorDaVez().getPecaSelecionada() == null) {
            return;
        }
        if (posicaoClicada.getPeca() != null) {
            exibirMensagem("Posicao nao disponivel");
        } else {

            try {
                posicaoClicada.setPeca(partida.getJogadorDaVez().getPecaSelecionada());
                posicaoClicada.setJogadorDono(partida.getJogadorDaVez());

                partida.getJogadorDaVez().limparPecaDeck();
                partida.getJogadorDaVez().removerSeForCasteloJogador();

                //
                if (partida.isPartidaEmRede()) {
                    enviarMinhaPeca(partida.getJogadorDaVez().getPecaSelecionada(), posicaoClicada.getLinha(), posicaoClicada.getColuna());
                }
                //

                partida.getJogadorDaVez().setPecaSelecionada(null);

                qtdePecasLivresTabuleiro--;

                verificarPosicaoLivreDisponivel();

                partida.alternarJogadorDaVez();
                //
                if (partida.isPartidaEmRede()) {
                    enviarMinhaPontuacao();
                }

            } catch (Exception ex) {
                Logger.getLogger(Tabuleiro.class.getName()).log(Level.SEVERE, null, ex);
            }
//                exibirMensagem("selecionado");
        }

    }

    public void pegarPeca(AtorJogador jogadorSelecionado) {
        if (partida.isJogadorDaVez(jogadorSelecionado)) {
            jogadorSelecionado.setPecaSelecionada(criarPecaAleatoria());
        }
    }

    private void exibeMensagemGanhador() {
        partida.definirGanhador();

        if (partida.getVencedorPartida() != null) {
            exibirMensagem("Vencedor da partida jogador:" + partida.getVencedorPartida().getNome());
        } else {
            exibirMensagem("Empate");
        }
        qtdePecasLivresTabuleiro = linhas * colunas;

        //
        Ranking ran = new Ranking();
        ran.adicionarRank(partida.getJogador1().getNome(), partida.getJogador1().getPontuacao());
        ran.adicionarRank(partida.getJogador2().getNome(), partida.getJogador2().getPontuacao());
        //
        
        destruirPanelJogo();
    }

    //coisas netgames
    public void receberJogada(Mensagem msg) {
        if (msg.getTipoMensagem().equals(TipoMensagem.OCUPAR_POSICAO)) {
            Posicao pos = posicoes[msg.getLinha()][msg.getColuna()];
            pos.setPeca(msg.getPeca());
            pos.setJogadorDono(partida.getJogador2());
            partida.getJogador2().removerSeForCasteloJogador(msg.getPeca());
            //
            partida.alternarJogadorDaVez();
        } else if (msg.getTipoMensagem().equals(TipoMensagem.PONTUACAO)) {
            partida.getJogador2().setPontuacao(msg.getPontuacao());
        } else if (msg.getTipoMensagem().equals(TipoMensagem.MENSAGEM_TEXTO)) {
            exibirMensagem(msg.getMensagem());
        } else if (msg.getTipoMensagem().equals(TipoMensagem.NOVA_RODADA)) {
            partida.novaRodada();
            iniciarNovaRodada();
        } else {
            exibirMensagem("mensagem desconhecida, q porra eh essa?");
        }
    }

    private void comunicarNovaRodada() {
        atorNetgames.enviarJogada(new Mensagem(TipoMensagem.NOVA_RODADA));
    }

    private void enviarMinhaPontuacao() {
        atorNetgames.enviarJogada(new Mensagem(partida.getJogador1().getPontuacao()));

    }

    private void enviarMinhaPeca(Peca peca, int linha, int coluna) {
        atorNetgames.enviarJogada(new Mensagem(peca, linha, coluna));
    }

    public void fechar() {
        this.atorNetgames.desconectar();
    }

    public void conexaoPerdida() {
        destruirPanelJogo();
        exibirMensagem("fechado por perda de conexao ou coisa do tipo");
    }

    public void contarPontosJogadores() {
        int pontosJogador1 = partida.getJogador1().getPontuacao();
        int pontosJogador2 = partida.getJogador2().getPontuacao();

        for (int i = 0; i < linhas; i++) {
            int pontos = getPontosDaLinha(i);
//            System.out.println("Pontos na linha " + i + ":" + pontos);
            pontosJogador1 += pontos * getPontoCastelosJogadorLinha(partida.getJogador1(), i);
            pontosJogador2 += pontos * getPontoCastelosJogadorLinha(partida.getJogador2(), i);
        }

        for (int i = 0; i < colunas; i++) {
            int pontos = getPontosDaColuna(i);
//            System.out.println("Pontos na coluna " + i + ":" + pontos);
            pontosJogador1 += pontos * getPontoCastelosJogadorColuna(partida.getJogador1(), i);
            pontosJogador2 += pontos * getPontoCastelosJogadorColuna(partida.getJogador2(), i);

        }

        partida.getJogador1().setPontuacao(pontosJogador1);
        partida.getJogador2().setPontuacao(pontosJogador2);
    }

    public void tratarIniciarPartida(Integer posicao) {
        //
        partida.setJogador2(new AtorJogador(this, 2, this.atorNetgames.informarNomeAdversario(partida.getJogador1().getNome()), Color.BLUE));
        //
        construirPecasParaCadaJogador();
        //
        criarElementosGraficosPartida();
        //
        if (posicao == 1) {
            partida.setJogadorDaVez(partida.getJogador1());
        } else {
            partida.setJogadorDaVez(partida.getJogador2());
        }
        partida.iniciar();
    }

    public int getPontosDaLinha(int linha) {
        int p = 0;

        boolean dragao = contemDragaoNaLinha(linha);
        boolean mina = contemMinaNaLinha(linha);

        for (int i = 0; i < colunas; i++) {
            Posicao pos = posicoes[linha][i];
            if (pos.getPeca() != null) {
                if (!pos.getPeca().getTipoPeca().equals(EnumTipoPeca.CASTELO)) {
                    int pon = pos.getPeca().getPontos();

                    System.out.println("Peca na linha " + i + " do tipo" + pos.getPeca().getTipoPeca() + " pontos:" + pon);

                    if (pon > 0 && mina) {
                        pon = pon * 2;
                    }

                    if (pon > 0 && dragao) {
                        pon = 0;
                    }

                    p += pon;
                }
            }
        }

        return p;
    }

    public int getPontoCastelosJogadorLinha(AtorJogador jogador, int linha) {
        int pontosCastelo = 0;
        for (int i = 0; i < colunas; i++) {
            Posicao pos = posicoes[linha][i];
            if (pos.getPeca() != null && pos.getJogadorDono() != null) {
                if (pos.getJogadorDono().equals(jogador)) {
                    if (pos.getPeca().getTipoPeca().equals(EnumTipoPeca.CASTELO)) {
                        pontosCastelo += pos.getPeca().getPontos();
                    }
                }
            }
        }

        return pontosCastelo;
    }

    public boolean contemDragaoNaLinha(int linha) {
        for (int i = 0; i < colunas; i++) {
            Posicao pos = posicoes[linha][i];
            if (pos.getPeca() != null) {
                if (pos.getPeca().getTipoPeca().equals(EnumTipoPeca.DRAGAO)) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean contemMinaNaLinha(int linha) {
        for (int i = 0; i < colunas; i++) {
            Posicao pos = posicoes[linha][i];
            if (pos.getPeca() != null) {
                if (pos.getPeca().getTipoPeca().equals(EnumTipoPeca.MINA)) {
                    return true;
                }
            }
        }

        return false;
    }

    //Por Coluna
    public int getPontosDaColuna(int coluna) {
        int p = 0;

        boolean dragao = contemDragaoNaColuna(coluna);
        boolean mina = contemMinaNaColuna(coluna);

        for (int i = 0; i < linhas; i++) {
            Posicao pos = posicoes[i][coluna];

            if (pos.getPeca() != null) {
                if (!pos.getPeca().getTipoPeca().equals(EnumTipoPeca.CASTELO)) {
                    int pon = pos.getPeca().getPontos();

                    if (pon > 0 && mina) {
                        pon = pon * 2;
                    }

                    if (pon > 0 && dragao) {
                        pon = 0;
                    }

                    p += pon;
                }
            }
        }

        return p;
    }

    public int getPontoCastelosJogadorColuna(AtorJogador jogador, int coluna) {
        int pontosCastelo = 0;
        for (int i = 0; i < linhas; i++) {
            Posicao pos = posicoes[i][coluna];
            if (pos.getPeca() != null && pos.getJogadorDono() != null) {
                if (pos.getJogadorDono().equals(jogador)) {
                    if (pos.getPeca().getTipoPeca().equals(EnumTipoPeca.CASTELO)) {
                        pontosCastelo += pos.getPeca().getPontos();
                    }
                }
            }
        }

        return pontosCastelo;
    }

    public boolean contemDragaoNaColuna(int coluna) {
        for (int i = 0; i < linhas; i++) {
            Posicao pos = posicoes[i][coluna];
            if (pos.getPeca() != null) {
                if (pos.getPeca().getTipoPeca().equals(EnumTipoPeca.DRAGAO)) {
                    return true;
                }
            }
        }
        return false;
    }

    public boolean contemMinaNaColuna(int coluna) {
        for (int i = 0; i < linhas; i++) {
            Posicao pos = posicoes[i][coluna];
            if (pos.getPeca() != null) {
                if (pos.getPeca().getTipoPeca().equals(EnumTipoPeca.MINA)) {
                    return true;
                }
            }
        }
        return false;
    }

    public JPanel getPanelPosicoes() {
        return panelPosicoes;
    }

    public void setPanelPosicoes(JPanel panelPosicoes) {
        this.panelPosicoes = panelPosicoes;
    }

    public JPanel getPanelPrincipal() {
        return panelPrincipal;
    }

    public void setPanelPrincipal(JPanel panelPrincipal) {
        this.panelPrincipal = panelPrincipal;
    }

    public int getLinhas() {
        return linhas;
    }

    public void setLinhas(int linhas) {
        this.linhas = linhas;
    }

    public int getColunas() {
        return colunas;
    }

    public void setColunas(int colunas) {
        this.colunas = colunas;
    }

    public Posicao[][] getPosicoes() {
        return posicoes;
    }

    public void setPosicoes(Posicao[][] posicoes) {
        this.posicoes = posicoes;
    }

    public int getQtdePecasLivresTabuleiro() {
        return qtdePecasLivresTabuleiro;
    }

    public void setQtdePecasLivresTabuleiro(int qtdePecasLivresTabuleiro) {
        this.qtdePecasLivresTabuleiro = qtdePecasLivresTabuleiro;
    }

    public EnumTipoPeca[] getTiposPecas() {
        return tiposPecas;
    }

    public void setTiposPecas(EnumTipoPeca[] tiposPecas) {
        this.tiposPecas = tiposPecas;
    }

    public HashMap<EnumTipoPeca, ImageIcon> getMapTipoPecaImageIcon() {
        return mapTipoPecaImageIcon;
    }

    public void setMapTipoPecaImageIcon(HashMap<EnumTipoPeca, ImageIcon> mapTipoPecaImageIcon) {
        this.mapTipoPecaImageIcon = mapTipoPecaImageIcon;
    }

    public AtorNetGames getAtorNetgames() {
        return atorNetgames;
    }

    public void setAtorNetgames(AtorNetGames atorNetgames) {
        this.atorNetgames = atorNetgames;
    }

    public String getIpServidorNetgames() {
        return ipServidorNetgames;
    }

    public void setIpServidorNetgames(String ipServidorNetgames) {
        this.ipServidorNetgames = ipServidorNetgames;
    }

    public Partida getPartida() {
        return partida;
    }

    public void setPartida(Partida partida) {
        this.partida = partida;
    }

    private void atualizarPlacar() {
        partida.getJogador1().atualizarSeuPlacar();
        partida.getJogador2().atualizarSeuPlacar();
    }

    private void verificarPosicaoLivreDisponivel() {
        if (qtdePecasLivresTabuleiro == 20) {
            partida.novaRodada();

            if (!partida.isPartidaEmRede()) {
                contarPontosJogadores();
                atualizarPlacar();
            }

//            if (!partida.isPartidaEmAndamento()) {
//                exibeMensagemGanhador();
//            } else {
                iniciarNovaRodada();
                if (partida.isPartidaEmRede()) {
                    comunicarNovaRodada();
                }
                //
//            }

        }

    }

    private void exibirRanking() {
        JDialog dialogRanking = new JDialog(this);
        dialogRanking.setSize(1024, 600);
        dialogRanking.setLayout(new FlowLayout());

        Ranking ranking = new Ranking();
        JTable tabela = ranking.getTabelaRanking();

        JScrollPane scrollPane = new JScrollPane(tabela);
        tabela.setFillsViewportHeight(true);
        dialogRanking.add(scrollPane);

        dialogRanking.setVisible(true);
    }
}
